{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-*- coding: utf-8 -*-"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# time标准库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t_local time.struct_time(tm_year=2021, tm_mon=1, tm_mday=31, tm_hour=19, tm_min=0, tm_sec=37, tm_wday=6, tm_yday=31, tm_isdst=0)\n",
      "t_UTC time.struct_time(tm_year=2021, tm_mon=1, tm_mday=31, tm_hour=11, tm_min=0, tm_sec=37, tm_wday=6, tm_yday=31, tm_isdst=0)\n",
      "Sun Jan 31 19:00:37 2021\n"
     ]
    }
   ],
   "source": [
    "#time库 python处理时间的标准库\n",
    "#获取现在时间  time.localtime()\n",
    "#获取UTC世界统一时间 time.gmtime   北京时间比统一时间早8个小时\n",
    "import time\n",
    "t_local = time.localtime()\n",
    "t_UTC = time.gmtime()\n",
    "print(\"t_local\",t_local) #本地时间\n",
    "print(\"t_UTC\",t_UTC) #UTC统一时间\n",
    "print(time.ctime()) #返回本地时间的字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1612090853.10497\n",
      "1839724.696770838\n",
      "1.0332949999999999\n"
     ]
    }
   ],
   "source": [
    "#时间戳与计时器\n",
    "#time.time() 返回自纪元以来的秒数，记录sleep\n",
    "#time.perf_counter() 随意选取一个时间点，记录现在时间到该时间点间隔秒数，记录 sleep\n",
    "#time.process_time() 随意选取一个时间点，记录现在时间到该时间点间隔秒数，不记录 sleep\n",
    "#perf_counter()精度比time()更高一些\n",
    "t_1_start = time.time()\n",
    "t_2_start = time.perf_counter()\n",
    "t_3_start = time.process_time()\n",
    "print(t_1_start)\n",
    "print(t_2_start)\n",
    "print(t_3_start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-01-31 Sunday 19:01:00\n"
     ]
    }
   ],
   "source": [
    "#时间格式化输出 time.triftime 自定义格式化输出\n",
    "lctime = time.localtime()\n",
    "print(time.strftime(\"%Y-%m-%d %A %H:%M:%S\",lctime))\n",
    "#睡眠\n",
    "time.sleep(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# random标准库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5714025946899135\n",
      "0.5714025946899135\n"
     ]
    }
   ],
   "source": [
    "#python通过random库提供各种伪随机数\n",
    "#随机种子 -- seed（a=None）\n",
    "#相同种子会产生相同随机数，如果不设置随机种子，以系统当前时间为默认值\n",
    "from random import *\n",
    "seed(10)\n",
    "print(random())\n",
    "seed(10)\n",
    "print(random())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 8, 10, 1, 4, 8, 8, 5, 3, 1]\n",
      "[8, 7, 5, 1, 3, 5, 0, 6, 2, 9]\n",
      "[4, 6, 6, 4, 4, 6, 2, 4, 4, 2]\n"
     ]
    }
   ],
   "source": [
    "#产生随机整数\n",
    "#randint(a,b) -- 产生[a,b]之间的随机整数\n",
    "numbers = [randint(1,10) for i in range(10)]\n",
    "print(numbers)\n",
    "#randrange(a) -- 产生[0,a)之间的随机整数,不包含a\n",
    "numbers = [randrange(10) for i in range(10)]\n",
    "print(numbers)\n",
    "#randrange(a,b,step) -- 产生[a,b)之间以step为步长的随机整数\n",
    "numbers = [randrange(0,10,2) for i in range(10)]\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.4569284228074387, 0.8600491433025393, 0.23938029236635683, 0.4396477759877355, 0.3752429935653554, 0.5829315558378036, 0.23565393041053806, 0.19495330706985492, 0.9095882423435193, 0.5363451642255902]\n",
      "[3.1808776666035854, 2.43625518560491, 3.0333659318728374, 2.7308722019973644, 2.757963553748964, 3.014168824392294, 2.5545635981984067, 2.8026838289125746, 3.2790451579840374, 3.457697102263706]\n"
     ]
    }
   ],
   "source": [
    "#产生随机浮点数\n",
    "#random()--产生[0.0,1.0]之间的随机浮点数\n",
    "numbers = [random() for i in range(10)]\n",
    "print(numbers)\n",
    "#uniform(a,b)-- 产生[a,b]之间的随机浮点数\n",
    "numbers = [uniform(2.1,3.5) for i in range(10)]\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "win\n",
      "python\n"
     ]
    }
   ],
   "source": [
    "#序列用函数\n",
    "#choice(seq)--从序列类型中随机返回一个元素\n",
    "print(choice(['win','lose','draw']))\n",
    "print(\"python\")\n",
    "#choices(seq,weights=None,k) --对序列类型进行k次重复采样，可设置权重"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['win', 'lose', 'draw', 'lose', 'lose']\n",
      "['draw', 'win', 'lose', 'win', 'lose', 'win', 'lose', 'win', 'win', 'draw']\n",
      "['one', 'four', 'two', 'three']\n",
      "[40, 20, 30]\n",
      "-0.2142534770549066\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([  1.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,\n",
       "          0.,   1.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   0.,   1.,   0.,   0.,   0.,\n",
       "          2.,   1.,   0.,   0.,   0.,   2.,   0.,   0.,   0.,   0.,   1.,\n",
       "          1.,   0.,   1.,   1.,   0.,   0.,   0.,   0.,   2.,   0.,   0.,\n",
       "          1.,   1.,   0.,   1.,   0.,   1.,   1.,   3.,   1.,   0.,   0.,\n",
       "          1.,   2.,   0.,   2.,   2.,   1.,   1.,   0.,   3.,   2.,   0.,\n",
       "          2.,   2.,   1.,   3.,   1.,   0.,   1.,   1.,   3.,   1.,   4.,\n",
       "          1.,   1.,   2.,   3.,   2.,   0.,   2.,   4.,   3.,   6.,   2.,\n",
       "          4.,   3.,   5.,   1.,   4.,   5.,   7.,   2.,   6.,   2.,   1.,\n",
       "          3.,   1.,   5.,   7.,   5.,   5.,   5.,   4.,   3.,   6.,   6.,\n",
       "          2.,   6.,   3.,   0.,   7.,   5.,   6.,  10.,   8.,   5.,   7.,\n",
       "          3.,   3.,   2.,  11.,  11.,  10.,   8.,   5.,   4.,  10.,  10.,\n",
       "          8.,   8.,   7.,   5.,   5.,   5.,   2.,   9.,  12.,  10.,   7.,\n",
       "         11.,  13.,   7.,   9.,  11.,  14.,  10.,  17.,  16.,  23.,  15.,\n",
       "         20.,  14.,  16.,  17.,  11.,  19.,  13.,  16.,  20.,  22.,  15.,\n",
       "         23.,   9.,  19.,  16.,  26.,  25.,  15.,  19.,  18.,  17.,  23.,\n",
       "         21.,  26.,  26.,  24.,  26.,  33.,  38.,  29.,  32.,  36.,  32.,\n",
       "         31.,  32.,  35.,  33.,  34.,  31.,  45.,  42.,  38.,  36.,  39.,\n",
       "         37.,  39.,  60.,  35.,  37.,  47.,  39.,  34.,  52.,  48.,  45.,\n",
       "         46.,  55.,  53.,  60.,  45.,  51.,  49.,  45.,  46.,  63.,  53.,\n",
       "         54.,  62.,  51.,  52.,  50.,  63.,  57.,  55.,  62.,  62.,  67.,\n",
       "         65.,  60.,  57.,  67.,  66.,  93.,  74.,  91.,  77.,  80.,  78.,\n",
       "         63.,  73.,  84.,  79.,  88.,  92.,  69.,  83.,  90.,  81., 107.,\n",
       "         84.,  88., 104.,  95.,  89., 113., 123., 104., 103., 116., 108.,\n",
       "        101., 121., 129., 132., 128., 111., 135., 121., 113., 115., 136.,\n",
       "        138., 141., 121., 133., 131., 178., 168., 136., 136., 154., 154.,\n",
       "        140., 136., 168., 150., 155., 137., 179., 163., 175., 147., 178.,\n",
       "        160., 187., 159., 172., 169., 178., 158., 198., 197., 204., 179.,\n",
       "        194., 199., 172., 243., 229., 186., 196., 213., 199., 200., 241.,\n",
       "        218., 192., 241., 218., 216., 217., 245., 227., 234., 247., 247.,\n",
       "        239., 243., 242., 227., 253., 273., 260., 248., 264., 241., 286.,\n",
       "        271., 263., 290., 282., 267., 285., 274., 245., 279., 290., 288.,\n",
       "        308., 289., 262., 334., 307., 294., 303., 300., 317., 293., 306.,\n",
       "        291., 289., 321., 307., 308., 315., 329., 354., 326., 325., 304.,\n",
       "        341., 339., 309., 339., 343., 348., 323., 369., 362., 306., 357.,\n",
       "        350., 350., 360., 324., 336., 332., 323., 317., 347., 362., 320.,\n",
       "        370., 336., 344., 350., 357., 392., 341., 347., 367., 370., 346.,\n",
       "        337., 365., 354., 359., 376., 387., 368., 355., 364., 366., 364.,\n",
       "        362., 361., 324., 372., 370., 389., 358., 389., 370., 370., 343.,\n",
       "        374., 339., 390., 402., 353., 368., 390., 367., 337., 380., 346.,\n",
       "        370., 372., 348., 368., 389., 335., 388., 360., 363., 343., 338.,\n",
       "        343., 346., 359., 382., 353., 352., 334., 340., 378., 370., 345.,\n",
       "        319., 370., 363., 339., 364., 346., 378., 346., 356., 344., 334.,\n",
       "        358., 343., 334., 357., 348., 321., 344., 318., 313., 350., 377.,\n",
       "        354., 303., 321., 318., 334., 351., 309., 319., 323., 309., 317.,\n",
       "        330., 294., 294., 315., 310., 297., 302., 301., 293., 310., 319.,\n",
       "        298., 283., 275., 286., 271., 279., 278., 277., 234., 259., 294.,\n",
       "        276., 279., 261., 276., 277., 263., 269., 270., 243., 278., 262.,\n",
       "        236., 256., 208., 237., 227., 201., 228., 237., 244., 245., 212.,\n",
       "        214., 209., 233., 225., 166., 221., 209., 197., 224., 184., 193.,\n",
       "        193., 185., 188., 173., 200., 191., 179., 174., 166., 174., 190.,\n",
       "        187., 189., 157., 196., 170., 152., 147., 171., 152., 138., 152.,\n",
       "        155., 132., 165., 145., 163., 152., 123., 123., 156., 143., 125.,\n",
       "        123., 128., 117., 130., 124., 123., 123., 123., 110., 128., 122.,\n",
       "        117., 107., 109., 120., 120., 102., 111., 122., 127.,  98., 108.,\n",
       "        105., 103.,  86.,  94.,  94.,  93.,  88.,  85.,  84.,  79.,  81.,\n",
       "         70.,  75.,  85.,  73.,  74.,  81.,  74.,  71.,  82.,  65.,  72.,\n",
       "         72.,  64.,  60.,  72.,  60.,  68.,  61.,  61.,  53.,  60.,  63.,\n",
       "         56.,  59.,  55.,  56.,  53.,  50.,  55.,  52.,  49.,  47.,  47.,\n",
       "         45.,  57.,  51.,  42.,  43.,  42.,  38.,  53.,  48.,  45.,  51.,\n",
       "         31.,  33.,  48.,  34.,  33.,  29.,  30.,  27.,  35.,  36.,  30.,\n",
       "         27.,  27.,  22.,  37.,  26.,  28.,  33.,  28.,  27.,  25.,  26.,\n",
       "         20.,  23.,  21.,  28.,  23.,  16.,  20.,  18.,  16.,  19.,  23.,\n",
       "         14.,  16.,  18.,  17.,  18.,  24.,  17.,  19.,  13.,   9.,  18.,\n",
       "         15.,  11.,  13.,  10.,  14.,  14.,  14.,  14.,   7.,  15.,  10.,\n",
       "         13.,  13.,  14.,   9.,  11.,   7.,   7.,   6.,   7.,   3.,   7.,\n",
       "          6.,   6.,   6.,   8.,   9.,   7.,   6.,   7.,   4.,   7.,  10.,\n",
       "          4.,  13.,   6.,  10.,  12.,   5.,   6.,   7.,   3.,   2.,   2.,\n",
       "          0.,   4.,   6.,   3.,   4.,   6.,   3.,   4.,   7.,   3.,   3.,\n",
       "          1.,   2.,   4.,   5.,   5.,   0.,   3.,   3.,   1.,   3.,   1.,\n",
       "          4.,   3.,   2.,   2.,   0.,   2.,   1.,   1.,   2.,   2.,   3.,\n",
       "          3.,   1.,   1.,   1.,   0.,   6.,   4.,   1.,   3.,   0.,   2.,\n",
       "          1.,   1.,   1.,   0.,   0.,   0.,   2.,   4.,   0.,   1.,   1.,\n",
       "          0.,   1.,   1.,   1.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,\n",
       "          0.,   1.,   1.,   0.,   1.,   0.,   0.,   2.,   1.,   1.,   0.,\n",
       "          0.,   0.,   0.,   0.,   1.,   1.,   0.,   0.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,\n",
       "          1.,   0.,   0.,   0.,   0.,   0.,   1.,   1.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   1.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   1.,   1.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   1.,   0.,   0.,   0.,   1.,   1.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   1.]),\n",
       " array([-4.29301758, -4.28374102, -4.27446447, ...,  4.96498569,\n",
       "         4.97426225,  4.98353881]),\n",
       " <a list of 1000 Patch objects>)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#重复采样5次,取完之后放回再取\n",
    "print(choices(['win','lose','draw'],k=5))\n",
    "#可对每个元素设置权重\n",
    "print(choices(['win','lose','draw'],[4,4,2],k=10))\n",
    "#shuffle(seq) 将序列类型中元素随机排列，返回打乱后对序列\n",
    "numbers = [\"one\",\"two\",\"three\",\"four\"]\n",
    "shuffle(numbers)\n",
    "print(numbers)\n",
    "#sample(pop,k) -- 从pop类型中随机取k个元素，以列表类型返回\n",
    "print(sample([10,20,30,40,50],k=3))\n",
    "#概率分布  以高斯分布为例\n",
    "#gauss(mean,std) 生产一个符合高斯分布的随机数 mean是均值 std是标准差\n",
    "number = gauss(0,1)\n",
    "print(number)\n",
    "#多生成几个画直方图显示\n",
    "import matplotlib.pyplot as plt\n",
    "res = [gauss(0,1) for i in range(100000)]\n",
    "plt.hist(res,bins=1000)\n",
    "#plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# collections标准库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point(x=1, y=2)\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "#提供容器数据类型，可以看作之前学习过的组合数据类型的扩展\n",
    "#namedtuple，具名元组，即有名字的元组\n",
    "#构建一个新的元组子类，定义方法如下：typename是元组名字，field_names是域名, 即元组里面要存的元素的名字\n",
    "import collections\n",
    "#collections.namedtuple(typename,field_names,*,rename=False,defaults=None,module=None)\n",
    "Point = collections.namedtuple(\"Point\",[\"x\",\"y\"])\n",
    "#对Point对域名赋值，完成初始化操作\n",
    "p = Point(1,y=2)\n",
    "print(p)\n",
    "#p作为一个元组，具有元组的属性，可以调用属性，解包赋值\n",
    "print(p.x)\n",
    "print(p.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "1\n",
      "2\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#有元组的性质\n",
    "print(p[0])\n",
    "print(p[1])\n",
    "x,y = p\n",
    "print(x)\n",
    "print(y)\n",
    "print(isinstance(p,tuple))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'奶': 5, '牛': 2, '找': 1, '刘': 1, '买': 1})\n",
      "Counter({'blue': 3, 'red': 2, 'green': 1})\n"
     ]
    }
   ],
   "source": [
    "#Counter  计数器工具\n",
    "from collections import Counter\n",
    "s = \"牛奶奶找刘奶奶买牛奶\"\n",
    "colors = ['red','blue','red','green','blue','blue']\n",
    "cnt_str = Counter(s)\n",
    "cnt_color = Counter(colors)\n",
    "print(cnt_str)\n",
    "print(cnt_color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "[('blue', 3), ('red', 2)]\n",
      "['牛', '牛', '奶', '奶', '奶', '奶', '奶', '找', '刘', '买']\n",
      "Counter({'a': 4, 'b': 3})\n"
     ]
    }
   ],
   "source": [
    "#Counter是字典类型的子类\n",
    "print(isinstance(Counter(),dict))\n",
    "#最常见的统计 -- most_commom(n) 提供n个频率最高的元组和计数\n",
    "#比如打印出cnt_color中2个出现频率最高的元素和计数\n",
    "print(cnt_color.most_common(2))\n",
    "#将已经统计好的元素展开 -- elements()\n",
    "print(list(cnt_str.elements()))\n",
    "#其他一些加减操作\n",
    "c = Counter(a=3,b=1)\n",
    "d = Counter(a=1,b=2)\n",
    "print(c+d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque(['c', 'd', 'e'])\n",
      "deque(['g', 'b', 'c', 'd', 'e', 'f', 'g'])\n",
      "deque(['b', 'c', 'd', 'e', 'f'])\n"
     ]
    }
   ],
   "source": [
    "#双向队列 可以方便的在队列两边高效、快速的增加和删除元素\n",
    "from collections import deque\n",
    "d = deque('cde')\n",
    "print(d)\n",
    "d.append(\"f\") #右端增加\n",
    "d.append(\"g\")\n",
    "d.appendleft(\"b\")#左端增加\n",
    "d.appendleft(\"g\")\n",
    "print(d)\n",
    "d.pop()  #右端删除\n",
    "d.popleft()#左端删除\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# itertools标准库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A', '0')\n",
      "('A', '1')\n",
      "('B', '0')\n",
      "('B', '1')\n",
      "('C', '0')\n",
      "('C', '1')\n",
      "('A', 'A', 'A')\n",
      "('A', 'A', 'B')\n",
      "('A', 'A', 'C')\n",
      "('A', 'B', 'A')\n",
      "('A', 'B', 'B')\n",
      "('A', 'B', 'C')\n",
      "('A', 'C', 'A')\n",
      "('A', 'C', 'B')\n",
      "('A', 'C', 'C')\n",
      "('B', 'A', 'A')\n",
      "('B', 'A', 'B')\n",
      "('B', 'A', 'C')\n",
      "('B', 'B', 'A')\n",
      "('B', 'B', 'B')\n",
      "('B', 'B', 'C')\n",
      "('B', 'C', 'A')\n",
      "('B', 'C', 'B')\n",
      "('B', 'C', 'C')\n",
      "('C', 'A', 'A')\n",
      "('C', 'A', 'B')\n",
      "('C', 'A', 'C')\n",
      "('C', 'B', 'A')\n",
      "('C', 'B', 'B')\n",
      "('C', 'B', 'C')\n",
      "('C', 'C', 'A')\n",
      "('C', 'C', 'B')\n",
      "('C', 'C', 'C')\n",
      "('A', 'B', 'C')\n",
      "('A', 'B', 'D')\n",
      "('A', 'C', 'B')\n",
      "('A', 'C', 'D')\n",
      "('A', 'D', 'B')\n",
      "('A', 'D', 'C')\n",
      "('B', 'A', 'C')\n",
      "('B', 'A', 'D')\n",
      "('B', 'C', 'A')\n",
      "('B', 'C', 'D')\n",
      "('B', 'D', 'A')\n",
      "('B', 'D', 'C')\n",
      "('C', 'A', 'B')\n",
      "('C', 'A', 'D')\n",
      "('C', 'B', 'A')\n",
      "('C', 'B', 'D')\n",
      "('C', 'D', 'A')\n",
      "('C', 'D', 'B')\n",
      "('D', 'A', 'B')\n",
      "('D', 'A', 'C')\n",
      "('D', 'B', 'A')\n",
      "('D', 'B', 'C')\n",
      "('D', 'C', 'A')\n",
      "('D', 'C', 'B')\n",
      "(0, 1, 2)\n",
      "(0, 2, 1)\n",
      "(1, 0, 2)\n",
      "(1, 2, 0)\n",
      "(2, 0, 1)\n",
      "(2, 1, 0)\n",
      "('A', 'B')\n",
      "('A', 'C')\n",
      "('A', 'D')\n",
      "('B', 'C')\n",
      "('B', 'D')\n",
      "('C', 'D')\n",
      "(0, 1, 2)\n",
      "(0, 1, 3)\n",
      "(0, 2, 3)\n",
      "(1, 2, 3)\n",
      "('A', 'A')\n",
      "('A', 'B')\n",
      "('A', 'C')\n",
      "('B', 'B')\n",
      "('B', 'C')\n",
      "('C', 'C')\n",
      "('A', 'A')\n",
      "('A', 'B')\n",
      "('A', 'C')\n",
      "('B', 'A')\n",
      "('B', 'B')\n",
      "('B', 'C')\n",
      "('C', 'A')\n",
      "('C', 'B')\n",
      "('C', 'C')\n"
     ]
    }
   ],
   "source": [
    "#itertools标准库中有很多产生迭代器的方法\n",
    "#排列组合迭代器\n",
    "#product  -- 笛卡尔积\n",
    "import itertools\n",
    "for i in itertools.product('ABC','01'):\n",
    "    print(i)\n",
    "for i in itertools.product('ABC',repeat = 3):\n",
    "    print (i)\n",
    "#permutations  排列\n",
    "for i in itertools.permutations('ABCD',3):  #从ABCD中取3个进行排列，3是排列的长度\n",
    "    print(i)\n",
    "for i in itertools.permutations(range(3)):\n",
    "    print(i)\n",
    "\n",
    "#combinations 组合\n",
    "for i in itertools.combinations('ABCD',2): #2是组合的长度\n",
    "    print(i)\n",
    "for i in itertools.combinations(range(4),3):\n",
    "    print(i)\n",
    "#combinations_with_replacement -- 元素可重复组合\n",
    "for i in itertools.combinations_with_replacement('ABC',2): #2是组合的长度\n",
    "    print(i)\n",
    "for i in itertools.product('ABC',repeat=2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A', '0', 'x')\n",
      "('B', '1', 'y')\n",
      "('C', '2', 'z')\n",
      "('A', '0')\n",
      "('B', '1')\n",
      "('C', '2')\n",
      "('A', '0')\n",
      "('B', '1')\n",
      "('C', '2')\n",
      "(None, '3')\n",
      "(None, '4')\n",
      "(None, '5')\n",
      "('A', '0')\n",
      "('B', '1')\n",
      "('C', '2')\n",
      "('?', '3')\n",
      "('?', '4')\n",
      "('?', '5')\n"
     ]
    }
   ],
   "source": [
    "#拉链\n",
    "#zip -- 短拉链\n",
    "for i in zip(\"ABC\",\"012\",\"xyz\"):\n",
    "    print(i)\n",
    "#长度不一致时，执行到最短的对象处，就停止\n",
    "for i in zip(\"ABC\",\"012345\"):\n",
    "    print(i)\n",
    "#长度不一致时，执行到最长对象处，就停止，缺省的元素用None或指定字符替代\n",
    "for i in itertools.zip_longest(\"ABC\",\"012345\"):\n",
    "    print(i)\n",
    "for i in itertools.zip_longest(\"ABC\",\"012345\",fillvalue=\"?\"):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count(10)\n",
      "<itertools.cycle object at 0x1349578b8>\n"
     ]
    }
   ],
   "source": [
    "#无穷迭代器\n",
    "#count(start=0,step=1) 计数\n",
    "#创建一个迭代器 它从start值开始，返回均匀间隔的值\n",
    "print(itertools.count(10))\n",
    "#cycle  循环\n",
    "#创建一个迭代器，返回iterable中所有元素，无限重复\n",
    "print(itertools.cycle(\"ABC\"))\n",
    "#repeat(object[,times]) --重复\n",
    "#其他迭代器\n",
    "#chain(iterables)  锁链 把一组迭代对象串联起来 形成一个更大的迭代器\n",
    "#enumerate(iterable,start=0) 枚举 python内置\n",
    "#groupby(iterable,key=None) 分组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}